Trusted Types API: เสริมสร้างความปลอดภัยผ่านการจัดการ DOM อย่างปลอดภัย

ในการต่อสู้กับช่องโหว่บนเว็บที่ไม่สิ้นสุด การโจมตีแบบ Cross-Site Scripting (XSS) ยังคงเป็นภัยคุกคามที่เกิดขึ้นอย่างต่อเนื่อง การโจมตีเหล่านี้ใช้ประโยชน์จากช่องโหว่ในเว็บแอปพลิเคชันเพื่อแทรกสคริปต์ที่เป็นอันตรายเข้าไปในเว็บไซต์ที่น่าเชื่อถือ ทำให้นักโจมตีสามารถขโมยข้อมูลที่ละเอียดอ่อน, ทำลายหน้าตาเว็บไซต์ หรือเปลี่ยนเส้นทางผู้ใช้ไปยังเว็บไซต์ที่เป็นอันตรายได้ เพื่อต่อสู้กับปัญหานี้ Trusted Types API จึงได้ถือกำเนิดขึ้นในฐานะกลไกป้องกันอันทรงพลัง ซึ่งช่วยส่งเสริมการจัดการ DOM อย่างปลอดภัยและลดความเสี่ยงของช่องโหว่ XSS ได้อย่างมีนัยสำคัญ

ทำความเข้าใจ Cross-Site Scripting (XSS)

การโจมตีแบบ XSS เกิดขึ้นเมื่อข้อมูลที่ผู้ใช้ป้อนเข้ามาถูกนำไปแสดงผลบนหน้าเว็บโดยไม่มีการคัดกรอง (Sanitization) หรือการเข้ารหัส (Encoding) ที่เหมาะสม XSS มี 3 ประเภทหลักๆ ได้แก่:

• Stored XSS: สคริปต์ที่เป็นอันตรายจะถูกเก็บไว้ถาวรบนเซิร์ฟเวอร์เป้าหมาย (เช่น ในฐานข้อมูล, โพสต์ในฟอรัม หรือส่วนความคิดเห็น) เมื่อผู้ใช้คนอื่นเข้าถึงข้อมูลที่เก็บไว้นั้น สคริปต์จะถูกรันในเบราว์เซอร์ของพวกเขา
• Reflected XSS: สคริปต์ที่เป็นอันตรายจะถูกฝังอยู่ใน URL หรือการส่งฟอร์ม และถูกสะท้อนกลับไปยังผู้ใช้ในทันทีในการตอบสนอง โดยปกติแล้วจะเกี่ยวข้องกับการหลอกล่อให้ผู้ใช้คลิกลิงก์ที่เป็นอันตราย
• DOM-based XSS: สคริปต์ที่เป็นอันตรายจะใช้ประโยชน์จากช่องโหว่ในโค้ด JavaScript ฝั่งไคลเอ็นต์โดยตรง แทนที่จะอาศัยการจัดเก็บข้อมูลหรือการสะท้อนกลับจากฝั่งเซิร์ฟเวอร์ ซึ่งมักจะเกี่ยวข้องกับการจัดการ Document Object Model (DOM) โดยตรง

ตามธรรมเนียมแล้ว นักพัฒนาจะอาศัยการตรวจสอบอินพุตและการเข้ารหัสเอาต์พุตเพื่อป้องกันการโจมตี XSS แม้ว่าเทคนิคเหล่านี้จะจำเป็น แต่ก็มีความซับซ้อนในการนำไปใช้อย่างถูกต้องและมักเกิดข้อผิดพลาดได้ง่าย Trusted Types API นำเสนอแนวทางที่แข็งแกร่งและเป็นมิตรกับนักพัฒนามากขึ้น โดยการบังคับใช้แนวทางการเขียนโค้ดที่ปลอดภัยในระดับ DOM

แนะนำ Trusted Types API

Trusted Types API เป็นฟีเจอร์ความปลอดภัยของแพลตฟอร์มเว็บที่ช่วยให้นักพัฒนาเขียนเว็บแอปพลิเคชันที่ปลอดภัยยิ่งขึ้น โดยการจำกัดการใช้เมธอดจัดการ DOM ที่อาจเป็นอันตราย มันบังคับใช้กฎที่ว่า DOM XSS sinks (ตำแหน่งที่อาจเกิดการแทรกสคริปต์ได้) จะสามารถยอมรับได้เฉพาะค่าที่ผ่านการคัดกรองอย่างชัดเจนและถูกห่อหุ้มด้วย "Trusted Type" เท่านั้น สิ่งนี้เป็นการสร้างระบบประเภท (type system) สำหรับสตริงที่ใช้ในการจัดการ DOM ซึ่งข้อมูลที่ไม่น่าเชื่อถือจะไม่สามารถส่งไปยัง sinks เหล่านี้ได้โดยตรง

แนวคิดหลัก:

• DOM XSS Sinks: คือคุณสมบัติและเมธอดที่มักใช้ในการแทรกสคริปต์เข้าไปในหน้าเว็บ ตัวอย่างเช่น innerHTML, outerHTML, src, href และ document.write
• Trusted Types: คืออ็อบเจ็กต์พิเศษที่ทำหน้าที่ห่อหุ้มสตริง เพื่อบ่งชี้ว่าสตริงนั้นได้รับการตรวจสอบอย่างละเอียดแล้วและปลอดภัยที่จะใช้ใน DOM XSS sink โดย API มี Trusted Types ในตัวหลายประเภท เช่น TrustedHTML, TrustedScript และ TrustedScriptURL
• Type Policies: คือกฎที่กำหนดวิธีการสร้างและใช้งาน Trusted Types โดยจะระบุว่าฟังก์ชันใดได้รับอนุญาตให้สร้าง Trusted Types และสตริงพื้นฐานจะถูกคัดกรองหรือตรวจสอบความถูกต้องอย่างไร

Trusted Types ทำงานอย่างไร

หลักการสำคัญของ Trusted Types คือการป้องกันไม่ให้นักพัฒนาส่งสตริงที่ไม่น่าเชื่อถือไปยัง DOM XSS sinks โดยตรง เมื่อเปิดใช้งาน Trusted Types เบราว์เซอร์จะโยนข้อผิดพลาด TypeError หากมีการใช้สตริงธรรมดาในตำแหน่งที่คาดหวัง Trusted Type

ในการใช้ Trusted Types คุณต้องกำหนด type policy ก่อน type policy คืออ็อบเจ็กต์ JavaScript ที่ระบุวิธีการสร้าง Trusted Types ตัวอย่างเช่น:

if (window.trustedTypes && window.trustedTypes.createPolicy) {
  window.myPolicy = trustedTypes.createPolicy('myPolicy', {
    createHTML: function(input) {
      // ทำการ Sanitize อินพุตที่นี่ นี่เป็นเพียงตัวอย่าง ควรใช้ไลบรารี sanitization จริง
      let sanitized = DOMPurify.sanitize(input); // ตัวอย่างการใช้ DOMPurify
      return sanitized;
    },
    createScriptURL: function(input) {
      // ตรวจสอบความถูกต้องของอินพุตที่นี่เพื่อให้แน่ใจว่าเป็น URL ที่ปลอดภัย
      if (input.startsWith('https://example.com/')) {
        return input;
      } else {
        throw new Error('Untrusted URL: ' + input);
      }
    },
    createScript: function(input) {
         //โปรดระมัดระวังอย่างยิ่งในการสร้างสคริปต์ ทำก็ต่อเมื่อคุณรู้ว่ากำลังทำอะไรอยู่
         return input;
    }
  });
}

ในตัวอย่างนี้ เราสร้าง type policy ชื่อ "myPolicy" ซึ่งมีสามฟังก์ชันคือ createHTML, createScriptURL และ createScript ฟังก์ชัน createHTML จะทำการคัดกรองสตริงอินพุตโดยใช้ไลบรารี sanitization เช่น DOMPurify ฟังก์ชัน createScriptURL จะตรวจสอบความถูกต้องของอินพุตเพื่อให้แน่ใจว่าเป็น URL ที่ปลอดภัย ส่วนฟังก์ชัน createScript ควรใช้อย่างระมัดระวังสูงสุด และควรหลีกเลี่ยงหากเป็นไปได้ เนื่องจากอนุญาตให้รันสคริปต์ใดๆ ก็ได้

เมื่อสร้าง type policy แล้ว คุณสามารถใช้มันเพื่อสร้าง Trusted Types ได้:

let untrustedHTML = '';
let trustedHTML = myPolicy.createHTML(untrustedHTML);

document.getElementById('myElement').innerHTML = trustedHTML;

ในตัวอย่างนี้ เราส่งสตริง HTML ที่ไม่น่าเชื่อถือไปยังฟังก์ชัน createHTML ของ type policy ของเรา ฟังก์ชันจะทำการคัดกรองสตริงและส่งคืนอ็อบเจ็กต์ TrustedHTML จากนั้นเราสามารถกำหนดอ็อบเจ็กต์ TrustedHTML นี้ให้กับคุณสมบัติ innerHTML ขององค์ประกอบได้อย่างปลอดภัยโดยไม่ต้องเสี่ยงต่อการโจมตี XSS

ประโยชน์ของการใช้ Trusted Types

• ความปลอดภัยที่เพิ่มขึ้น: Trusted Types ช่วยลดความเสี่ยงของการโจมตี XSS ได้อย่างมีนัยสำคัญ โดยป้องกันไม่ให้นักพัฒนาส่งสตริงที่ไม่น่าเชื่อถือไปยัง DOM XSS sinks โดยตรง
• คุณภาพโค้ดที่ดีขึ้น: Trusted Types กระตุ้นให้นักพัฒนาคิดอย่างรอบคอบเกี่ยวกับการคัดกรองและตรวจสอบข้อมูล ซึ่งนำไปสู่คุณภาพโค้ดและแนวทางปฏิบัติด้านความปลอดภัยที่ดีขึ้น
• การตรวจสอบความปลอดภัยที่ง่ายขึ้น: Trusted Types ทำให้การระบุและตรวจสอบช่องโหว่ XSS ที่อาจเกิดขึ้นในโค้ดทำได้ง่ายขึ้น เนื่องจากการใช้ DOM XSS sinks ถูกควบคุมอย่างชัดเจนโดย type policies
• ความเข้ากันได้กับ CSP: Trusted Types สามารถใช้ร่วมกับ Content Security Policy (CSP) เพื่อเพิ่มความปลอดภัยให้กับเว็บแอปพลิเคชันได้อีกชั้น

ข้อควรพิจารณาในการนำไปใช้

การนำ Trusted Types ไปใช้งานจำเป็นต้องมีการวางแผนและการดำเนินการอย่างรอบคอบ นี่คือข้อควรพิจารณาที่สำคัญบางประการ:

• ระบุ DOM XSS Sinks: ขั้นตอนแรกคือการระบุ DOM XSS sinks ทั้งหมดในแอปพลิเคชันของคุณ ซึ่งได้แก่คุณสมบัติและเมธอดที่ใช้ในการจัดการ DOM และอาจถูกใช้ประโยชน์จากการโจมตี XSS ได้
• เลือกไลบรารี Sanitization: เลือกไลบรารี sanitization ที่มีชื่อเสียงและได้รับการดูแลอย่างดีเพื่อคัดกรองข้อมูลที่ไม่น่าเชื่อถือก่อนสร้าง Trusted Types โดย DOMPurify เป็นตัวเลือกที่ได้รับความนิยมและมีประสิทธิภาพ อย่าลืมกำหนดค่าให้ถูกต้องตามความต้องการเฉพาะของคุณ
• กำหนด Type Policies: สร้าง type policies ที่ระบุวิธีการสร้างและใช้งาน Trusted Types พิจารณาตรรกะการคัดกรองและตรวจสอบความถูกต้องใน type policies ของคุณอย่างรอบคอบเพื่อให้แน่ใจว่ามีประสิทธิภาพในการป้องกันการโจมตี XSS
• อัปเดตโค้ด: อัปเดตโค้ดของคุณเพื่อใช้ Trusted Types ทุกครั้งที่คุณจัดการ DOM ด้วยข้อมูลที่อาจไม่น่าเชื่อถือ แทนที่การกำหนดค่าโดยตรงให้กับ DOM XSS sinks ด้วยการกำหนดค่าของ Trusted Types
• ทดสอบอย่างละเอียด: ทดสอบแอปพลิเคชันของคุณอย่างละเอียดหลังจากการนำ Trusted Types ไปใช้เพื่อให้แน่ใจว่าทำงานได้อย่างถูกต้องและไม่มีข้อผิดพลาดถดถอย (regressions) ให้ความสนใจเป็นพิเศษกับส่วนที่คุณกำลังจัดการ DOM
• กลยุทธ์การย้ายระบบ: การนำ Trusted Types ไปใช้กับโค้ดเบสขนาดใหญ่ที่มีอยู่แล้วอาจเป็นเรื่องท้าทาย พิจารณากลยุทธ์การย้ายระบบแบบค่อยเป็นค่อยไป โดยเริ่มจากส่วนที่สำคัญที่สุดของแอปพลิเคชันของคุณ คุณสามารถเปิดใช้งาน Trusted Types ในโหมด "report-only" ในช่วงแรกเพื่อระบุการละเมิดโดยไม่ทำให้แอปพลิเคชันของคุณเสียหาย

ตัวอย่างสถานการณ์

เรามาดูตัวอย่างการใช้งานจริงของ Trusted Types ในสถานการณ์ต่างๆ กัน:

สถานการณ์ที่ 1: การแสดงเนื้อหาที่สร้างโดยผู้ใช้

เว็บไซต์แห่งหนึ่งอนุญาตให้ผู้ใช้ส่งความคิดเห็นและโพสต์ หากไม่มี Trusted Types การแสดงเนื้อหานี้อาจเสี่ยงต่อการโจมตี XSS แต่ด้วยการใช้ Trusted Types คุณสามารถคัดกรองเนื้อหาที่ผู้ใช้สร้างขึ้นก่อนที่จะแสดงผล เพื่อให้แน่ใจว่าสคริปต์ที่เป็นอันตรายทั้งหมดจะถูกลบออกไป

// ก่อนใช้ Trusted Types:
// document.getElementById('comments').innerHTML = userComment; // เสี่ยงต่อการโจมตี XSS

// หลังใช้ Trusted Types:
let trustedHTML = myPolicy.createHTML(userComment);
document.getElementById('comments').innerHTML = trustedHTML;

สถานการณ์ที่ 2: การโหลดไฟล์ JavaScript ภายนอก

เว็บไซต์แห่งหนึ่งทำการโหลดไฟล์ JavaScript จากแหล่งภายนอกแบบไดนามิก หากไม่มี Trusted Types ผู้โจมตีอาจสามารถแทนที่ไฟล์เหล่านี้ด้วยสคริปต์ที่เป็นอันตรายของตนเองได้ แต่ด้วยการใช้ Trusted Types คุณสามารถตรวจสอบ URL ของไฟล์สคริปต์ก่อนที่จะโหลด เพื่อให้แน่ใจว่ามาจากแหล่งที่น่าเชื่อถือ

// ก่อนใช้ Trusted Types:
// let script = document.createElement('script');
// script.src = untrustedURL; // เสี่ยงต่อการโจมตี XSS
// document.head.appendChild(script);

// หลังใช้ Trusted Types:
let trustedScriptURL = myPolicy.createScriptURL(untrustedURL);
let script = document.createElement('script');
script.src = trustedScriptURL;
document.head.appendChild(script);

สถานการณ์ที่ 3: การตั้งค่าแอตทริบิวต์ขององค์ประกอบ

เว็บไซต์แห่งหนึ่งตั้งค่าแอตทริบิวต์บนองค์ประกอบ DOM ตามข้อมูลที่ผู้ใช้ป้อนเข้ามา เช่น การตั้งค่าแอตทริบิวต์ `href` ของแท็ก anchor หากไม่มี Trusted Types ผู้โจมตีอาจแทรก JavaScript URI ซึ่งนำไปสู่ XSS ได้ แต่ด้วย Trusted Types คุณสามารถตรวจสอบ URL ก่อนที่จะตั้งค่าแอตทริบิวต์

// ก่อนใช้ Trusted Types:
// anchorElement.href = userInputURL; // เสี่ยงต่อการโจมตี XSS

// หลังใช้ Trusted Types:
let trustedURL = myPolicy.createScriptURL(userInputURL);
anchorElement.href = trustedURL;

Trusted Types และ Content Security Policy (CSP)

Trusted Types ทำงานร่วมกับ Content Security Policy (CSP) ได้เป็นอย่างดีเพื่อสร้างการป้องกันเชิงลึก (defense-in-depth) ต่อการโจมตี XSS โดย CSP เป็นกลไกความปลอดภัยที่ช่วยให้คุณสามารถระบุแหล่งที่มาของเนื้อหาที่ได้รับอนุญาตให้โหลดบนเว็บไซต์ของคุณได้ การผสมผสาน Trusted Types กับ CSP จะช่วยให้คุณสามารถสร้างเว็บแอปพลิเคชันที่มีความปลอดภัยสูงได้

ในการเปิดใช้งาน Trusted Types ใน CSP คุณสามารถใช้คำสั่ง require-trusted-types-for ได้ คำสั่งนี้ระบุว่าจำเป็นต้องใช้ Trusted Types สำหรับ DOM XSS sinks ทั้งหมด ตัวอย่างเช่น:

Content-Security-Policy: require-trusted-types-for 'script'; trusted-types myPolicy;

ส่วนหัว CSP นี้จะบอกเบราว์เซอร์ให้ต้องการ Trusted Types สำหรับการรันสคริปต์ทั้งหมด และอนุญาตเฉพาะ Trusted Types ที่สร้างโดย type policy ชื่อ "myPolicy" เท่านั้น

การรองรับของเบราว์เซอร์และ Polyfills

การรองรับ Trusted Types ในเบราว์เซอร์กำลังเติบโตขึ้น แต่ยังไม่สามารถใช้ได้ในทุกเบราว์เซอร์ ณ ปลายปี 2024 เบราว์เซอร์หลักๆ เช่น Chrome, Firefox และ Edge รองรับได้ดี แต่การรองรับใน Safari ยังคงตามหลังอยู่ สามารถตรวจสอบข้อมูลความเข้ากันได้ล่าสุดของเบราว์เซอร์ได้ที่ CanIUse.com

สำหรับเบราว์เซอร์รุ่นเก่าที่ไม่รองรับ Trusted Types โดยกำเนิด คุณสามารถใช้ polyfill ได้ polyfill คือโค้ด JavaScript ที่ให้ฟังก์ชันการทำงานของฟีเจอร์ใหม่ๆ ในเบราว์เซอร์รุ่นเก่า มี polyfills ของ Trusted Types ให้เลือกใช้หลายตัว เช่น ตัวที่ Google ให้บริการ อย่างไรก็ตาม polyfills ไม่ได้ให้ความปลอดภัยในระดับเดียวกับการรองรับแบบเนทีฟ แต่จะช่วยในเรื่องความเข้ากันได้เป็นหลักและช่วยให้คุณเริ่มใช้ API ได้แม้ว่าผู้ใช้บางส่วนของคุณจะใช้เบราว์เซอร์รุ่นเก่าก็ตาม

ทางเลือกและข้อควรพิจารณาอื่น ๆ

แม้ว่า Trusted Types จะช่วยเพิ่มความปลอดภัยได้อย่างมาก แต่ก็เป็นสิ่งสำคัญที่จะต้องพิจารณาถึงแนวทางทางเลือกและสถานการณ์ที่อาจไม่เหมาะสมที่สุด:

• การผสานรวมกับเฟรมเวิร์ก: เฟรมเวิร์ก JavaScript สมัยใหม่ เช่น React, Angular และ Vue.js มักจะจัดการ DOM ในลักษณะที่ช่วยลดความเสี่ยงจาก XSS โดยเฟรมเวิร์กเหล่านี้มักจะทำการ escape ข้อมูลโดยค่าเริ่มต้นและสนับสนุนการใช้รูปแบบการเขียนโค้ดที่ปลอดภัย อย่างไรก็ตาม แม้จะใช้เฟรมเวิร์ก ก็ยังคงมีความเป็นไปได้ที่จะเกิดช่องโหว่ XSS หากคุณหลีกเลี่ยงการป้องกันในตัวของเฟรมเวิร์ก หรือใช้ dangerouslySetInnerHTML (React) หรือฟังก์ชันที่คล้ายกันอย่างไม่ถูกต้อง
• การตรวจสอบอินพุตและการเข้ารหัสเอาต์พุตอย่างเข้มงวด: วิธีการดั้งเดิมในการตรวจสอบอินพุตและการเข้ารหัสเอาต์พุตยังคงมีความสำคัญอย่างยิ่ง Trusted Types เป็นส่วนเสริมของเทคนิคเหล่านี้ ไม่ได้มาแทนที่ การตรวจสอบอินพุตช่วยให้แน่ใจว่าข้อมูลที่เข้ามาในแอปพลิเคชันของคุณมีรูปแบบที่ถูกต้องและสอดคล้องกับรูปแบบที่คาดไว้ การเข้ารหัสเอาต์พุตช่วยให้แน่ใจว่าข้อมูลถูก escape อย่างเหมาะสมเมื่อแสดงผลบนหน้าเว็บ ป้องกันไม่ให้เบราว์เซอร์ตีความว่าเป็นโค้ด
• ภาระด้านประสิทธิภาพ: แม้โดยทั่วไปจะน้อยมาก แต่ก็อาจมีภาระด้านประสิทธิภาพเล็กน้อยที่เกี่ยวข้องกับกระบวนการคัดกรองและตรวจสอบที่ Trusted Types ต้องการ สิ่งสำคัญคือต้องทำการโปรไฟล์แอปพลิเคชันของคุณเพื่อระบุคอขวดด้านประสิทธิภาพและปรับให้เหมาะสม
• ภาระในการบำรุงรักษา: การนำไปใช้และการบำรุงรักษา Trusted Types จำเป็นต้องมีความเข้าใจอย่างถ่องแท้เกี่ยวกับโครงสร้าง DOM และการไหลของข้อมูลในแอปพลิเคชันของคุณ การสร้างและจัดการ type policies อาจเพิ่มภาระในการบำรุงรักษาได้

ตัวอย่างการใช้งานจริงและกรณีศึกษา

มีหลายองค์กรที่นำ Trusted Types ไปใช้เพื่อปรับปรุงความปลอดภัยของเว็บแอปพลิเคชันได้สำเร็จ ตัวอย่างเช่น Google ได้ใช้ Trusted Types อย่างกว้างขวางในผลิตภัณฑ์และบริการของตน บริษัทอื่นๆ ในภาคการเงินและอีคอมเมิร์ซ ซึ่งความปลอดภัยเป็นสิ่งสำคัญยิ่ง ก็กำลังนำ Trusted Types มาใช้เพื่อปกป้องข้อมูลที่ละเอียดอ่อนของผู้ใช้และป้องกันการฉ้อโกงทางการเงิน ตัวอย่างการใช้งานจริงเหล่านี้แสดงให้เห็นถึงประสิทธิภาพของ Trusted Types ในการลดความเสี่ยงจาก XSS ในสภาพแวดล้อมที่ซับซ้อนและมีความเสี่ยงสูง

บทสรุป

Trusted Types API แสดงถึงก้าวสำคัญของความปลอดภัยในเว็บแอปพลิเคชัน โดยเป็นกลไกที่แข็งแกร่งและเป็นมิตรกับนักพัฒนาในการป้องกันการโจมตี XSS ด้วยการบังคับใช้แนวทางการจัดการ DOM ที่ปลอดภัยและส่งเสริมการคัดกรองและตรวจสอบข้อมูลอย่างรอบคอบ Trusted Types ช่วยให้นักพัฒนาสามารถสร้างเว็บแอปพลิเคชันที่ปลอดภัยและเชื่อถือได้มากขึ้น แม้ว่าการนำ Trusted Types ไปใช้จะต้องมีการวางแผนและการดำเนินการอย่างรอบคอบ แต่ประโยชน์ในแง่ของความปลอดภัยที่เพิ่มขึ้นและคุณภาพโค้ดที่ดีขึ้นนั้นคุ้มค่ากับความพยายามอย่างแน่นอน ในขณะที่การรองรับ Trusted Types ในเบราว์เซอร์ยังคงเติบโตอย่างต่อเนื่อง มันมีแนวโน้มที่จะกลายเป็นเครื่องมือที่สำคัญยิ่งขึ้นในการต่อสู้กับช่องโหว่บนเว็บ

ในฐานะผู้ใช้งานทั่วโลก การยอมรับแนวปฏิบัติที่ดีที่สุดด้านความปลอดภัย เช่น การใช้ Trusted Types ไม่ใช่แค่การปกป้องแอปพลิเคชันแต่ละตัวเท่านั้น แต่ยังเป็นการส่งเสริมเว็บที่ปลอดภัยและน่าเชื่อถือยิ่งขึ้นสำหรับทุกคน สิ่งนี้มีความสำคัญอย่างยิ่งในโลกยุคโลกาภิวัตน์ที่ข้อมูลไหลข้ามพรมแดนและการรั่วไหลของข้อมูลด้านความปลอดภัยอาจส่งผลกระทบในวงกว้าง ไม่ว่าคุณจะเป็นนักพัฒนาในโตเกียว ผู้เชี่ยวชาญด้านความปลอดภัยในลอนดอน หรือเจ้าของธุรกิจในเซาเปาโล การทำความเข้าใจและนำเทคโนโลยีอย่าง Trusted Types ไปใช้เป็นสิ่งจำเป็นสำหรับการสร้างระบบนิเวศดิจิทัลที่ปลอดภัยและยืดหยุ่น